home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Demos / A.D. Software / OOFILE / Buildable, limited OOFILE / source / GUI / zApp-old / oofzapp.cpp next >
Encoding:
Text File  |  1995-06-04  |  29.3 KB  |  1,263 lines  |  [TEXT/CWIE]
  1. // COPYRIGHT 1994 A.D. Software, All rights reserved
  2.  
  3. // zApp Integration layer of OOFILE database
  4. #include "zapp.hpp"
  5. #include "OOFzApp.hpp"
  6. #include "stdlib.h"
  7. #ifdef _Windows
  8.     #include <strstrea.h>
  9. #else
  10.     #include <strstream.h>
  11. #endif
  12. #include "fstream.h"
  13.  
  14.  // static variables
  15. dbEditMgr*  dbEditMgr::sFrontmost;
  16. zFont* dbEditMgr::sDefEditFont;
  17.  
  18. // utility function
  19.  
  20. char* newFileNameFromPath(const char*path) {
  21. #ifdef __BORLANDC__
  22.     char name[_MAX_FNAME];
  23.     char ext[_MAX_EXT];
  24.     char* ret;
  25.     int nameLen = _MAX_FNAME + _MAX_EXT;
  26.     _splitpath(path, 0, 0, name, ext);
  27.     ret = new char[nameLen];
  28.     assert(ret);
  29.     strcpy(ret, name);
  30.     strcat(ret, ext);
  31.     return ret;        // WARNING receiver must delete!
  32. #else
  33.     assert(0);   // force an error if function not avail
  34. #endif
  35. }
  36.  
  37.  
  38. // -------------------------------------------------------
  39. //                      d b E d i t M g r
  40. // -------------------------------------------------------
  41.  
  42. dbEditMgr::dbEditMgr() :
  43.                             mEditing(false),
  44.                             mNew(false),
  45.                             mChangingPages(false),
  46.                             mCurrPageCommandNum(0),
  47.                             mMenu(0),
  48.                             mCurrDialog(0),
  49.                      mPages(0),
  50.                             mDefEditFontSpec("MS Sans Serif", zDimension(0, -11),
  51.                                 FW_NORMAL, ffSwiss, VariablePitch,
  52.                                 0, 0, 0, AnsiCharSet, StringOutPrec, StrokeClipPrec, DraftQual)
  53. {
  54.     sFrontmost=this;
  55. };
  56.  
  57.  
  58. zFont* dbEditMgr::enableDefEditFont()
  59. {
  60. #ifdef OOF_Debug
  61.     if (sDefEditFont)
  62.         dbConnect::raise("dbEditMgr::enableDefEditFont called with non-zero font left in place");
  63. #endif
  64.     sDefEditFont = new zFont(mDefEditFontSpec);
  65.     return sDefEditFont;
  66. }
  67.  
  68. void dbEditMgr::setDefEditFont(zFont* theFont)
  69. {
  70. #ifdef OOF_Debug
  71.     if (sDefEditFont)
  72.         dbConnect::raise("dbEditMgr::setDefEditFont called with non-zero font left in place");
  73. #endif
  74.     sDefEditFont = theFont;
  75. }
  76.  
  77.  
  78. void dbEditMgr::leavingPage(zVBXFormDialog* leavingFrom)
  79. {
  80. // NOT IF RETAIN PAGES    delete sDefEditFont;
  81.    sDefEditFont = 0;
  82.     if (mChangingPages)
  83.         return;
  84.     if (leavingFrom->completed())
  85.         saveRecord();
  86.     mMainTable->unloadRecord();
  87.     mEditing = false;
  88.     mNew = false;
  89. }
  90.  
  91.  
  92.  void dbEditMgr::newRecord()
  93.  {
  94.     InvalidateAllPages();
  95.     assert(mMainTable);        // should be setup by now!
  96.     mNew = mEditing = true;
  97.     mMainTable->newRecord();
  98.     if (mCurrDialog) {   // left over from closing last form, NOT a page transition
  99. // NOT NEEDED - ALL OUR DIALOGS ARE deleteOnClose()        delete mCurrDialog;
  100.         mCurrDialog = 0;
  101.     }
  102. }
  103.  
  104.  
  105. void dbEditMgr::firstRecord()
  106. {
  107.     if (mEditing) {
  108.         InvalidateAllPages();
  109.         mMainTable->first();
  110.     }
  111.     else
  112.         browserSelectFirst();
  113. }
  114.  
  115.  
  116. void dbEditMgr::nextRecord()
  117. {
  118.     if (mEditing) {
  119.         InvalidateAllPages();
  120.         mMainTable->next();
  121.     }
  122.     else
  123.         browserSelectNext();
  124. }
  125.  
  126.  
  127. void dbEditMgr::prevRecord()
  128. {
  129.     if (mEditing) {
  130.         InvalidateAllPages();
  131.         mMainTable->prev();
  132.     }
  133.     else
  134.         browserSelectPrev();
  135. }
  136.  
  137.  
  138. void dbEditMgr::lastRecord()
  139. {
  140.     if (mEditing) {
  141.         InvalidateAllPages();
  142.         mMainTable->last();
  143.     }
  144.     else
  145.         browserSelectLast();
  146. }
  147.  
  148.  
  149. void dbEditMgr::InvalidateAllPages()
  150. {
  151.     unsigned int numPages = mPages.count();
  152.     for (unsigned int i=0; i<numPages; i++) {
  153.         OOF_MixEditPage* thePage = (OOF_MixEditPage*) mPages[i];  // safe downcast
  154.       thePage->invalidatePage();
  155.     }
  156. }
  157.  
  158.  
  159. void dbEditMgr::appendPage(OOF_MixEditPage* thePage)
  160. {
  161.     mPages.append((long) thePage);
  162. }
  163.  
  164.  
  165. void dbEditMgr::saveRecord()
  166. {
  167.     assert(mMainTable);        // should be setup by now!
  168.     mMainTable->saveRecord();
  169.     UpdateDisplayForEditedRecord();
  170. }
  171.  
  172. void dbEditMgr::UpdateDisplayForEditedRecord()
  173. {
  174. // do nothing - subclass overrides if it needs update
  175. }
  176.  
  177.  
  178.  void dbEditMgr::startPageTransition(zCommandEvt* ev)
  179. {
  180.     if (mMenu) {
  181.         if (mCurrPageCommandNum)
  182.             mMenu->checkItem(mCurrPageCommandNum, FALSE);
  183.     }
  184.  
  185.     if (mEditing) {
  186.         assert(mCurrDialog);  // leaving this one
  187.         mChangingPages = true;
  188.         mCurrDialog->endOk(ev);    // will trigger a callback to us leavingPage()
  189.         mChangingPages = false;
  190. // NOT NEEDED - ALL OUR DIALOGS ARE deleteOnClose()        delete mCurrDialog;
  191.         mCurrDialog = 0;     // in case some bright spark forgets to follow with completePageTransition
  192.     }
  193.     else
  194.         if (mCurrDialog) {  // is leftover from previous edit
  195. // NOT NEEDED - ALL OUR DIALOGS ARE deleteOnClose()        delete mCurrDialog;
  196.             mCurrDialog = 0;
  197.         }
  198.     mEditing = true;
  199. }
  200.  
  201.  
  202. void dbEditMgr ::completePageTransition(zVBXFormDialog* newDialog, const int newPageMenuItemNum)
  203. {
  204.     if (mMenu) {
  205.         mCurrPageCommandNum = newPageMenuItemNum;
  206.         if (mCurrPageCommandNum)
  207.             mMenu->checkItem(mCurrPageCommandNum, TRUE);
  208.     }
  209.     mCurrDialog = newDialog;
  210. }
  211.  
  212. void dbEditMgr::saveAsText(char* fileName)
  213. {
  214.     ofstream fs(fileName);
  215.     mDatabase->dumpData(fs);
  216.     fs.close();
  217. }
  218.  
  219.  
  220. void dbEditMgr::warnUser(ostream& os)
  221. {
  222. #ifdef __MWERKS__
  223.     cout << *(os.rdbuf());   // they don't define operator<<(streambuf*)
  224. #else
  225.     #ifdef _Windows
  226.         strstream oss;
  227.         oss << os.rdbuf() << ends;
  228.         char* s = oss.str();
  229.         ::MessageBox(0, s, "Warning", MB_ICONEXCLAMATION);
  230.         oss.rdbuf()->freeze(0);  // leave buffer for stream to delete
  231.     #else
  232.         cout << os.rdbuf();
  233.     #endif
  234. #endif
  235. }
  236.  
  237. // -------------------------------------------------------
  238. //              O O F _ M i x E d i t P a g e
  239. // -------------------------------------------------------
  240.  
  241. OOF_MixEditPage::OOF_MixEditPage(zVBXFormDialog* thisDialog, dbEditMgr* editMgr) :
  242.                                             mEditFont(0),
  243.                                             mEditMgr(editMgr),
  244.                                             mValid(true),
  245.                                             mThisDialog(thisDialog)
  246. {
  247.    mEditFont = mEditMgr->enableDefEditFont();  // must call before creating edit fields
  248.     mEditMgr->appendPage(this);
  249. }
  250.  
  251.  
  252. OOF_MixEditPage::~OOF_MixEditPage()
  253. {
  254.     delete mEditFont;
  255. }
  256.  
  257.  
  258. void OOF_MixEditPage::bringToFront()
  259. {
  260.     dbEditMgr::setDefEditFont(mEditFont);
  261.     if (!mValid) {
  262.         mThisDialog->setControlsToDefault();
  263.     }
  264.     mThisDialog->show();
  265. }
  266.  
  267.  
  268. // -------------------------------------------------------
  269. //              O O F _ M i x E d i t F i e l d
  270. // -------------------------------------------------------
  271. void OOF_MixEditField::CompleteInit(zControl* child)
  272. {
  273.     zFont* defFont = dbEditMgr::defEditFont();
  274.     if (defFont)
  275.         child->setFont(defFont, FALSE);
  276. }
  277.  
  278.  
  279. // -------------------------------------------------------
  280. //                    z d b E d i t L i n e
  281. // -------------------------------------------------------
  282.  
  283. zdbEditLine::zdbEditLine(zFrameWin* w, int id, dbChar& dest_, unsigned long flags) :
  284.                                 zEditLine(w, id, 0, flags),
  285.                                 mField(dest_)
  286. {
  287.     CompleteInit(this);
  288. }
  289.  
  290. int zdbEditLine::storeData() {
  291.     mField = text();
  292.     return 1;
  293. }
  294.  
  295.  
  296. int zdbEditLine::setToDefault() {
  297.     text(mField);
  298.     return 1;
  299. }
  300.  
  301.  
  302. // -------------------------------------------------------
  303. //                    z d b E d i t C o m b o
  304. // -------------------------------------------------------
  305.  
  306. zdbEditCombo::zdbEditCombo(zFrameWin* w, int id, dbChar& dest_, unsigned long flags) :
  307.                                 zComboBoxFull(w, id, (zString*)0, flags),
  308.                                 mField(dest_)
  309. {
  310.     CompleteInit(this);
  311. }
  312.  
  313. int zdbEditCombo::storeData() {
  314.     zString temp;
  315.     getEditText(temp);
  316.     mField = temp;
  317.     return 1;
  318. }
  319.  
  320.  
  321. int zdbEditCombo::setToDefault() {
  322.     add(mField);
  323.     selection(mField);
  324.     return 1;
  325. }
  326.  
  327.  
  328. // -------------------------------------------------------
  329. //                    z d b E d i t D a t e
  330. // -------------------------------------------------------
  331. zdbEditDate::zdbEditDate(zFrameWin* w, int id, dbDate& dest_, unsigned long flags) :
  332.                                 zEditLine(w, id, 0, flags),
  333.                                 mField(dest_)
  334. {
  335.     CompleteInit(this);
  336. }
  337.  
  338.  
  339.  
  340. int zdbEditDate::storeData() {
  341.     mField = text();
  342.     return 1;
  343. }  
  344.  
  345.  
  346. int zdbEditDate::setToDefault() {
  347.     text(mField);
  348.     return 1;
  349. }  
  350.  
  351.  
  352. // -------------------------------------------------------
  353. //                 z d b C h a r E d i t B o x
  354. // -------------------------------------------------------
  355. zdbCharEditBox::zdbCharEditBox(zWindow *w,zSizer* siz,DWORD style, dbChar& dest_, int id) :
  356.                         zEditBox(w, siz, style, 0, id),
  357.                         mField(dest_)
  358. {
  359. //    CompleteInit(this);
  360. }
  361.  
  362.  
  363. zdbCharEditBox::zdbCharEditBox(zFrameWin* w,int id, dbChar& dest_, unsigned long flags) :
  364.                         zEditBox(w, id, 0, flags),
  365.                         mField(dest_)
  366. {
  367. //    CompleteInit(this);
  368. }
  369.  
  370.  
  371. int zdbCharEditBox::storeData() {
  372.     mField = text();
  373.     return 1;
  374. }  
  375.  
  376.  
  377. int zdbCharEditBox::setToDefault() {
  378.     text(mField);
  379.     return 1;
  380. }
  381.  
  382.  
  383. // -------------------------------------------------------
  384. //                   z d b T e x t E d i t B o x
  385. // -------------------------------------------------------
  386. zdbTextEditBox::zdbTextEditBox(zWindow *w,zSizer* siz,DWORD style, dbText& dest_, int id) :
  387.                         zEditBox(w, siz, style, 0, id),
  388.                         mField(dest_)
  389. {
  390.     CompleteInit(this);
  391. }
  392.  
  393.  
  394. zdbTextEditBox::zdbTextEditBox(zFrameWin* w,int id, dbText& dest_, unsigned long flags) :
  395.                         zEditBox(w, id, 0, flags),
  396.                         mField(dest_)
  397. {
  398.     CompleteInit(this);
  399. }
  400.  
  401.  
  402. int zdbTextEditBox::storeData() {
  403.     mField = text();
  404.     return 1;
  405. } 
  406.  
  407.  
  408. int zdbTextEditBox::setToDefault() {
  409.     text(mField);
  410.     return 1;
  411. }  
  412.  
  413. // -------------------------------------------------------
  414. //               z d b R a d i o G r o u p
  415. // -------------------------------------------------------
  416. zdbRadioGroup::zdbRadioGroup(zFrameWin* w,int idLo, int idHi, dbShortInt& dest_) :
  417.                         zRadioGroup(w, idLo, idHi),
  418.                         mField(dest_)
  419. {
  420. //    CompleteInit(this);
  421. }
  422.  
  423. int zdbRadioGroup::storeData() {
  424.     int temp;
  425.     setStoreAddr(&temp);
  426.     zRadioGroup::storeData();        // let parent do all the formatting
  427.     mField = temp;                        // copy value back to record buffer via assignment
  428.     setStoreAddr(0);
  429.     return 1;
  430. }
  431.  
  432.  
  433. int zdbRadioGroup::setToDefault() {
  434.     int temp;
  435.     temp = mField;        // get value from record buffer via cast oper
  436.     setStoreAddr(&temp);
  437.     zRadioGroup::setToDefault();        // let the parent do the formatting
  438.     setStoreAddr(0);
  439.     return 1;
  440. }
  441.  
  442.  
  443.  
  444. // -------------------------------------------------------
  445. //                   z d b S h o r t E d i t
  446. // -------------------------------------------------------
  447. zdbShortEdit::zdbShortEdit(zFrameWin* w,int id, dbShortInt& dest_, char *pictStr, unsigned long flags) :
  448.                         zIntEdit(w, id, 0, pictStr, flags),
  449.                         mField(dest_)
  450. {
  451. //    CompleteInit(this);
  452. }
  453.  
  454.  
  455. zdbShortEdit::zdbShortEdit(zFrameWin* w,int id, dbShortInt& dest_, zFormatter *formatter, unsigned long flags) :
  456.                         zIntEdit(w, id, 0, formatter, flags),
  457.                         mField(dest_)
  458. {
  459. //    CompleteInit(this);
  460. }
  461.  
  462.  
  463. zdbShortEdit::zdbShortEdit(zFrameWin* w,int id, dbShortInt& dest_, unsigned long flags) :
  464.                         zIntEdit(w, id, 0, flags),
  465.                         mField(dest_)
  466. {
  467. //    CompleteInit(this);
  468. }
  469.  
  470. zdbShortEdit::zdbShortEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbShortInt& dest_, char *pictStr, unsigned long flags) :
  471.                         zIntEdit(w, siz, style, id, 0, pictStr, flags),
  472.                         mField(dest_)
  473. {
  474. //    CompleteInit(this);
  475. }
  476.  
  477. zdbShortEdit::zdbShortEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbShortInt& dest_, zFormatter *formatter, unsigned long flags) :
  478.                         zIntEdit(w, siz, style, id, 0, formatter, flags),
  479.                         mField(dest_)
  480. {
  481. //    CompleteInit(this);
  482. }
  483.  
  484. zdbShortEdit::zdbShortEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbShortInt& dest_, unsigned long flags) :
  485.                         zIntEdit(w, siz, style, id, 0, flags),
  486.                         mField(dest_)
  487. {
  488. //    CompleteInit(this);
  489. }
  490.  
  491.  
  492. int zdbShortEdit::storeData() {
  493.     int temp;
  494.     setStoreAddr(&temp);
  495.     zIntEdit::storeData();        // let parent do all the formatting
  496.     mField = temp;                        // copy value back to record buffer via assignment
  497.     setStoreAddr(0);
  498.     return 1;
  499. }
  500.  
  501.  
  502. int zdbShortEdit::setToDefault() {
  503.     int temp;
  504.     temp = mField;        // get value from record buffer via cast oper
  505.     setStoreAddr(&temp);
  506.     zIntEdit::setToDefault();        // let the parent do the formatting
  507.     setStoreAddr(0);
  508.     return 1;
  509. }
  510.  
  511.  
  512.  
  513. // -------------------------------------------------------
  514. //                   z d b L o n g E d i t
  515. // -------------------------------------------------------
  516. zdbLongEdit::zdbLongEdit(zFrameWin* w,int id, dbLong& dest_, char *pictStr, unsigned long flags) :
  517.                         zLongEdit(w, id, 0, pictStr, flags),
  518.                         mField(dest_)
  519. {
  520. //    CompleteInit(this);
  521. }
  522.  
  523.  
  524. zdbLongEdit::zdbLongEdit(zFrameWin* w,int id, dbLong& dest_, zFormatter *formatter, unsigned long flags) :
  525.                          zLongEdit(w, id, 0, formatter, flags),
  526.                         mField(dest_)
  527. {
  528. //    CompleteInit(this);
  529. }
  530.  
  531.  
  532. zdbLongEdit::zdbLongEdit(zFrameWin* w,int id, dbLong& dest_, unsigned long flags) :
  533.                          zLongEdit(w, id, 0, flags),
  534.                         mField(dest_)
  535. {
  536. //    CompleteInit(this);
  537. }
  538.  
  539.  
  540. zdbLongEdit::zdbLongEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbLong& dest_, char *pictStr, unsigned long flags) :
  541.                         zLongEdit(w, siz, style, id, 0, pictStr, flags),
  542.                         mField(dest_)
  543. {
  544. //    CompleteInit(this);
  545. }
  546.  
  547.  
  548. zdbLongEdit::zdbLongEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbLong& dest_, zFormatter *formatter, unsigned long flags) :
  549.                         zLongEdit(w, siz, style, id, 0, formatter, flags),
  550.                         mField(dest_)
  551. {
  552. //    CompleteInit(this);
  553. }
  554.  
  555.  
  556. zdbLongEdit::zdbLongEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbLong& dest_, unsigned long flags) :
  557.                         zLongEdit(w, siz, style, id, 0, flags),
  558.                         mField(dest_)
  559. {
  560. //    CompleteInit(this);
  561. }
  562.  
  563.  
  564. int zdbLongEdit::storeData() {
  565.     long temp;
  566.     setStoreAddr(&temp);
  567.     zLongEdit::storeData();
  568.     setStoreAddr(0);
  569.     mField = temp;
  570.     return 1;
  571. }  
  572.  
  573.  
  574. int zdbLongEdit::setToDefault() {
  575.     long temp;
  576.     temp = mField;
  577.     setStoreAddr(&temp);
  578.     zLongEdit::setToDefault();
  579.     setStoreAddr(0);
  580.     return 1;
  581. }
  582.  
  583.  
  584. int zdbLongEdit::checkData()
  585. {
  586.     if (mField.mHasRange) {
  587.         long temp;
  588.         setStoreAddr(&temp);
  589.         zLongEdit::storeData();
  590.         setStoreAddr(0);
  591.         if (mField.validate(temp))
  592.             return 1;
  593.         else {
  594.             dbEditMgr::warnUser(ostrstream() <<
  595.                 mField.fieldName() << " requires values between " << mField.mMin << " and "
  596.                 << mField.mMax
  597.             );
  598.             return 0;
  599.         }
  600.     }
  601.     else
  602.         return 1;
  603. }
  604.  
  605.  
  606. // -------------------------------------------------------
  607. //               z d b R e a l E d i t
  608. // -------------------------------------------------------
  609. zdbRealEdit::zdbRealEdit(zFrameWin* w,int id, dbReal& dest_, char *pictStr, unsigned long flags) :
  610.                          zDoubleEdit(w, id, 0, pictStr, flags),
  611.                         mField(dest_)
  612. {
  613. //    CompleteInit(this);
  614. }
  615.  
  616.  
  617. zdbRealEdit::zdbRealEdit(zFrameWin* w,int id, dbReal& dest_, zFormatter *formatter, unsigned long flags) :
  618.                          zDoubleEdit(w, id, 0, formatter, flags),
  619.                         mField(dest_)
  620. {
  621. //    CompleteInit(this);
  622. }
  623.  
  624.  
  625. zdbRealEdit::zdbRealEdit(zFrameWin* w,int id, dbReal& dest_, unsigned long flags) :
  626.                          zDoubleEdit(w, id, 0, flags),
  627.                         mField(dest_)
  628. {
  629. //    CompleteInit(this);
  630. }
  631.  
  632.  
  633. zdbRealEdit::zdbRealEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbReal& dest_, char *pictStr, unsigned long flags) :
  634.                         zDoubleEdit(w, siz, style, id, 0, pictStr, flags),
  635.                         mField(dest_)
  636. {
  637. //    CompleteInit(this);
  638. }
  639.  
  640.  
  641. zdbRealEdit::zdbRealEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbReal& dest_, zFormatter *formatter, unsigned long flags) :
  642.                         zDoubleEdit(w, siz, style, id, 0, formatter, flags),
  643.                         mField(dest_)
  644. {
  645. //    CompleteInit(this);
  646. }
  647.  
  648.  
  649. zdbRealEdit::zdbRealEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbReal& dest_, unsigned long flags) :
  650.                         zDoubleEdit(w, siz, style, id, 0, flags),
  651.                         mField(dest_)
  652. {
  653. //    CompleteInit(this);
  654. }
  655.  
  656.  
  657. int zdbRealEdit::storeData() {
  658.     double temp;
  659.     setStoreAddr(&temp);
  660.     zDoubleEdit::storeData();
  661.     mField = temp;
  662.     setStoreAddr(0);
  663.     return 1;
  664. }
  665.  
  666.  
  667. int zdbRealEdit::setToDefault() {
  668.     double temp;
  669.     temp = mField;
  670.     setStoreAddr(&temp);
  671.     zDoubleEdit::setToDefault();
  672.     setStoreAddr(0);
  673.     return 1;
  674. }
  675.  
  676.  
  677. // -------------------------------------------------------
  678. //            d b B r o w s e V R o w M o d e l
  679. // -------------------------------------------------------
  680. int dbBrowseVRowModel::discardRow(unsigned long row)
  681. {
  682.      return 1;         // no editing so no writeback
  683. }
  684.  
  685.  
  686. int dbBrowseVRowModel::demandLoadRow(unsigned long row)
  687. {
  688. //    if (!mFields.source()->gotoRelativeRecord(row-1))
  689. //        return 0;
  690. //    for (unsigned int i=0; i<mFields.count(); i++) {        // start field iteration (horizontal)
  691. //        dbField  *theField = (dbField  *) mFields[i];           // safe downcast
  692. //        char *theString = theField->copyAsChars();
  693. //        new zTableTextCell(this,theString,zTableLoc(i+1,row));
  694. //        delete[] theString;
  695. //    }
  696.      return 1;
  697. }
  698.  
  699.  
  700. void dbBrowseVRowModel::AppendBlankRow()
  701. {
  702.     InsertBlankRow(getNumRows()+1);
  703. }
  704.  
  705.  
  706. void dbBrowseVRowModel::InsertBlankRow(unsigned long row)
  707. {
  708.     for (unsigned int i=0; i<getNumCols(); i++)
  709.         new zTableTextCell(this,"",zTableLoc(i+1,row));
  710. }
  711.  
  712.  
  713. void dbBrowseVRowModel::coverWithReadOnly()
  714. {
  715. }
  716.  
  717. // -------------------------------------------------------
  718. //                 S S T a b l e _ S h e e t
  719. // -------------------------------------------------------
  720. void SSTable_Sheet::selectCol(unsigned int theCol)
  721. {
  722.     assert(theCol);   // 1-based columns
  723.     Col() = theCol;
  724.     Row() = -1;             // all rows
  725. }
  726.  
  727. void SSTable_Sheet::selectRow(unsigned int theRow)
  728. {
  729.     assert(theRow);   // 1-based rows
  730.     Row() = theRow;
  731.     Col() = -1;             // all cols
  732. }
  733.  
  734. //
  735. // parse Spread/VBX events down into something the table can use
  736. // in the process uncoupling our table logic from how they handle
  737. // editing changes
  738. //
  739.  
  740. void SSTable_Sheet::DblClick(long Col, long Row)
  741. {
  742.     mTable->receiveDoubleClick(Col, Row);
  743. }
  744.  
  745.  
  746. void SSTable_Sheet::EditMode(long Col, long Row, int Mode, int ChangeMade)
  747. {
  748.     if (Mode==1) {  // ENTERING
  749.         if (Row!=mCurRow) {
  750.             mCurRow = Row;
  751.             mTable->enterRow(Row);
  752.         }
  753.     }
  754.     else {
  755.         if (ChangeMade)
  756.             mTable->leaveModifiedCell(Col, Row);
  757.     }
  758. }
  759.  
  760.  
  761. // -------------------------------------------------------
  762. //                     S S T a b l e
  763. // -------------------------------------------------------
  764.  
  765. SSTable::SSTable(zWindow* w, zSizer* siz, int id_, DWORD style) :
  766.                         CVBControl(w, siz, id_, "SSPP20.VBX", "SpreadSheet", "SSPP20", style),
  767.                   mCurRow(-1)
  768. {
  769.     mSheet = new SSTable_Sheet(this);
  770.     assert(mSheet);
  771. }
  772.  
  773. SSTable::SSTable(zFrameWin* w, int id_) :
  774.                         CVBControl(w, id_),
  775.                   mCurRow(-1)
  776. {
  777.     mSheet = new SSTable_Sheet(this);
  778.     assert(mSheet);
  779. }
  780.  
  781.  
  782. SSTable::~SSTable()
  783. {
  784.     delete mSheet;
  785. }
  786.  
  787. unsigned long SSTable::countRowsSelected()
  788. {
  789.     if (mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT)
  790.         return 1;
  791.     else
  792.         return mSheet->SelModeSelCount();
  793. }
  794.  
  795.  
  796. unsigned long SSTable::selectedRow()
  797. {
  798.     unsigned long ret;
  799.     if (mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT)
  800.         ret = mSheet->SelModeIndex()-1;
  801.      else
  802.         ret = mSheet->GetMultiSelItem(0)-1;  // ASSUMES only one selected - you would NOT
  803.                                                     // call this method if multiple selection
  804.     mSheet->Row() = ret+1;   // set internal property to match so data updates correct row
  805.     return ret;
  806. }
  807.  
  808.  
  809. unsigned long SSTable::appendBlankRow()
  810. {
  811.     unsigned long newRow = mSheet->MaxRows()+1;
  812.     mSheet->MaxRows() = newRow;
  813.     mSheet->Row() = newRow;
  814.     mSheet->Action() = SS_ACTION_INSERT_ROW;
  815.     mCurRow = newRow;
  816.     return newRow;
  817. }
  818.  
  819. void SSTable::setRowColor(long newColor)
  820. {
  821.     mSheet->Col() =-1;  // whole row
  822.     mSheet->ForeColor() = newColor;
  823. }
  824.  
  825.  
  826. long SSTable::eventVBX(zVBXEvent *theEvent)
  827. {
  828.     VBXEVENT *ptrEvent = theEvent->event();
  829.     mSheet->CallEvent(ptrEvent->EventIndex, ptrEvent->ParamList);
  830.     return 0;
  831. }
  832.  
  833.  
  834. void SSTable::selectRow(unsigned int theRow)
  835. {
  836.     mSheet->selectRow(theRow);
  837.     if (mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT) {
  838.         mSheet->SelModeIndex() = theRow;
  839.         mSheet->SelModeSelected() = TRUE;
  840.     }
  841. }
  842.  
  843.  
  844.  
  845. // -------------------------------------------------------
  846. //                 d b S S V ie w T a b l e
  847. // -------------------------------------------------------
  848.  
  849. dbSSViewTable::dbSSViewTable(zWindow*w, zSizer* s, int id_, dbView& flds, DWORD style) :
  850.                                             SSTable(w, s, id_, style),
  851.                                             mFields(flds),
  852.                                             mHasWrappedCols(false)
  853. {
  854. }
  855.  
  856.  
  857. dbSSViewTable::dbSSViewTable(zFrameWin*w, int id_, dbView& flds) :
  858.                                             SSTable(w, id_),
  859.                                             mFields(flds),
  860.                                             mHasWrappedCols(false)
  861. {
  862. }
  863.  
  864.  
  865. void dbSSViewTable::SetColsFromView()
  866. {
  867.     SetColHeadingsFromView();
  868.     SetColWidthsFromView();
  869. }
  870.  
  871.  
  872. void dbSSViewTable::SetColHeadingsFromView()
  873. {
  874.     unsigned int numFields = mFields.count();
  875.     for (unsigned int col=0; col<numFields; col++) {        // start field iteration (horizontal)
  876.         dbField  *theField = (dbField  *) mFields[col];           // safe downcast
  877.         mSheet->SetText(col+1, 0, theField->fieldName());
  878.     }
  879. }
  880.  
  881.  
  882. void dbSSViewTable::SetColWidthsFromView()
  883. {
  884.     const int scrollBarWidth = 18;
  885.     const float twipsPerPixelFudgeFactor = 15.0;
  886.  
  887.     zRect sheetRect;
  888.     getInterior(sheetRect);   // device units (pixels) and include scrollbar?
  889. //    long totalTwips;
  890. //    mSheet->ColWidthToTwips(sheetRect.width(), totalTwips);
  891.     mSheet->UnitType() = SS_CELL_UNIT_TWIPS;
  892.  
  893.     unsigned int numFields = mFields.count();
  894.     unsigned long totalColWidth=0;
  895.     for (unsigned int i=0; i<numFields; i++) {
  896.         dbField  *theField = (dbField  *) mFields[i];           // safe downcast
  897.         totalColWidth += theField->fieldEditLen();
  898.     }
  899. //    float twipsPerColChar = totalTwips / totalColWidth;
  900.     mSheet->ReDraw() = FALSE;
  901.     int sheetWidth = sheetRect.width() - scrollBarWidth;
  902.     float twipsPerColChar = (sheetWidth * twipsPerPixelFudgeFactor) / totalColWidth ;
  903.     for (unsigned int col=0; col<numFields; col++) {        // start field iteration (horizontal)
  904.         dbField  *theField = (dbField  *) mFields[col];           // safe downcast
  905.         selectCol(col+1);
  906.         setCellTypeForField(theField);
  907.         mSheet->ColWidth() = twipsPerColChar * theField->fieldEditLen();
  908.     }
  909.     mSheet->ReDraw() = TRUE;
  910. }
  911.  
  912.  
  913. void dbSSViewTable::loadEntireTable()
  914. {
  915.     unsigned int numFields = mFields.count();
  916.     mFields.source()->start();
  917.     mSheet->ReDraw() = FALSE;
  918.     unsigned long numRows = mFields.source()->count();
  919.     for (unsigned long row=1; row<=numRows; row++) {    // iterate through records (vertical)
  920.         mSheet->Row() = row;
  921.         for (unsigned int col=0; col<numFields; col++) {        // start field iteration (horizontal)
  922.             dbField  *theField = (dbField *) mFields[col];           // safe downcast
  923.             char *str = theField->copyAsChars();
  924.             assert(str);
  925.             mSheet->SetText(col+1, row, str);
  926.             mSheet->Col() = col+1;
  927.             SetCellWidth(theField, str);
  928.             delete[] str;
  929.         }
  930.         adjustRowHeights();
  931.         mFields.source()->next();
  932.     }
  933.     mSheet->ReDraw() = TRUE;
  934. }
  935.  
  936.  
  937. void dbSSViewTable::addRowFromCurrentRecord()
  938. {
  939.     appendBlankRow();
  940.     redrawCurrentRecord(RGB(255, 0, 0));
  941. }
  942.  
  943.  
  944. void dbSSViewTable::redrawCurrentRecord(long newColor)
  945. {
  946.     int currentRow = mSheet->Row();
  947.     mSheet->ReDraw() = FALSE;
  948.     unsigned int numFields = mFields.count();
  949.     for (unsigned int col=0; col<numFields; col++) {        // start field iteration (horizontal)
  950.         dbField  *theField = (dbField  *) mFields[col];           // safe downcast
  951.         char *str = theField->copyAsChars();
  952.         mSheet->Col() =  col+1;
  953.         mSheet->Text() = str;
  954.         SetCellWidth(theField, str);
  955.     }
  956.     adjustRowHeights();
  957.     setRowColor(newColor);
  958. //    mSheet->OperationMode() = SS_OP_MODE_NORMAL;
  959.     mSheet->ReDraw() = TRUE;
  960.     mSheet->Col() = -1;
  961.     mSheet->Row() = -1;
  962.     mSheet->SortBy() = SS_SORT_BY_ROW;
  963.     mSheet->SortKey(1) = 1;
  964.     mSheet->SortKeyOrder(1)=SS_SORT_ORDER_ASCENDING;
  965.     mSheet->Action() = SS_ACTION_SORT;
  966. //    mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT;
  967.     selectRow(currentRow);
  968.     setDirty();
  969.     update();
  970. }
  971.  
  972.  
  973. short dbSSViewTable::cellTypeOfField(dbField* theField)
  974. {
  975.     switch (theField->fieldType()) {
  976.         case intField : return SS_CELL_TYPE_INTEGER;
  977.  
  978.         case longField : return SS_CELL_TYPE_INTEGER;
  979.  
  980.         case realField : return SS_CELL_TYPE_FLOAT;
  981.  
  982.         default : return SS_CELL_TYPE_EDIT;
  983.  
  984.     }
  985.     return SS_CELL_TYPE_EDIT;
  986. }
  987.  
  988. void dbSSViewTable::setCellTypeForField(dbField* theField)
  989. {
  990.     switch (theField->fieldType()) {
  991.         case intField : mSheet->CellType() = SS_CELL_TYPE_INTEGER;
  992.             break;
  993.  
  994.         case longField : mSheet->CellType() = SS_CELL_TYPE_INTEGER;
  995.             break;
  996.  
  997.         case realField : mSheet->CellType() = SS_CELL_TYPE_FLOAT;
  998.             break;
  999.  
  1000.         case dateField : colTypeIsDate(mSheet->Col(), "01011960", "12312010");
  1001.             break;
  1002.  
  1003.         default : mSheet->CellType() = SS_CELL_TYPE_EDIT;
  1004.     }
  1005. }
  1006.  
  1007. void dbSSViewTable::colTypeIsDate(const int colNum, const char* minDate, const char* maxDate)
  1008. {
  1009.     selectCol(colNum);
  1010.     mSheet->TypeDateCentury() = FALSE;
  1011.     mSheet->TypeHAlign() = SS_CELL_H_ALIGN_CENTER;
  1012.     mSheet->TypeDateFormat() = SS_CELL_DATE_FORMAT_DDMMYY;
  1013.    mSheet->CellType() = SS_CELL_TYPE_DATE;
  1014. //    if (minDate)
  1015. //        mSheet->TypeDateMin() = minDate;
  1016. //    if (maxDate)
  1017. //        mSheet->TypeDateMax() = maxDate;
  1018. }
  1019.  
  1020. void dbSSViewTable::colTypeIsCheck(const int colNum)
  1021. {
  1022. // see page 78 of SS reference
  1023.     selectCol(colNum);
  1024.     mSheet->CellType() = SS_CELL_TYPE_CHECKBOX;
  1025.     mSheet->TypeCheckText() = "";
  1026.     mSheet->TypeCheckCenter() = TRUE;
  1027. // FROM BOOK, the following is in several examples but crashed me!
  1028. //    mSheet->TypeCheckPicture(0) = mSheet->LoadPicture("");
  1029. //    mSheet->TypeCheckPicture(1) = mSheet->LoadPicture("");
  1030. //    mSheet->TypeCheckPicture(2) = mSheet->LoadPicture("");
  1031. //    mSheet->TypeCheckPicture(3) = mSheet->LoadPicture("");
  1032. //    mSheet->TypeCheckPicture(4) = mSheet->LoadPicture("");
  1033. //    mSheet->TypeCheckPicture(5) = mSheet->LoadPicture("");
  1034. }
  1035.  
  1036.  
  1037. void dbSSViewTable::colTypeIsCombo(const int colNum, const char* comboString)
  1038. {
  1039.     selectCol(colNum);
  1040.     mSheet->CellType() = SS_CELL_TYPE_COMBOBOX;
  1041.     mSheet->TypeComboBoxList() = comboString;
  1042.     mSheet->TypeComboBoxEditable() = FALSE;
  1043. }
  1044.  
  1045.  
  1046. void dbSSViewTable::colWrapsText(const int colNum)
  1047. {
  1048.     selectCol(colNum);
  1049.     mSheet->TypeEditMultiLine() = TRUE;
  1050.     mSheet->TypeTextWordWrap() = TRUE;
  1051.    mHasWrappedCols = true;
  1052. }
  1053.  
  1054.  
  1055. void dbSSViewTable::adjustRowHeights()
  1056. {
  1057.     if (mHasWrappedCols) {
  1058.         float fHeight = mSheet->MaxTextRowHeight();
  1059.       mSheet->RowHeight() = fHeight;
  1060.     }
  1061. }
  1062.  
  1063. void dbSSViewTable::SetCellWidth(dbField* theField, char* contents)
  1064. {
  1065.     if (theField->fieldType()!=textField)
  1066.         mSheet->TypeEditLen() = theField->fieldEditLen();
  1067.     else
  1068.     mSheet->TypeEditLen() = 16000;  // estimate
  1069. }
  1070.  
  1071. int dbSSViewTable::setToDefault()
  1072. {
  1073.     mSheet->MaxRows() =  mFields.source()->count();
  1074.     loadEntireTable();
  1075.     return 1;
  1076. }
  1077.  
  1078. // -------------------------------------------------------
  1079. //                     d b S S B r o w s e T a b l e
  1080. // -------------------------------------------------------
  1081. dbSSBrowseTable::dbSSBrowseTable(zWindow*w, zSizer* s, int id_, dbEditMgr* editMgr, dbView& flds, DWORD style) :
  1082.                                             dbSSViewTable(w, s, id_, flds, style),
  1083.                                             mEditMgr(editMgr)
  1084. {
  1085.     SetupSheet();
  1086.     SetColHeadingsFromView();
  1087. }
  1088.  
  1089.  
  1090. dbSSBrowseTable::dbSSBrowseTable(zFrameWin*w, int id_, dbEditMgr* editMgr, dbView& flds) :
  1091.                                             dbSSViewTable(w, id_, flds),
  1092.                                             mEditMgr(editMgr)
  1093. {
  1094.     SetupSheet();
  1095.     SetColHeadingsFromView();
  1096. }
  1097.  
  1098.  
  1099. void dbSSBrowseTable::SetupSheet()
  1100. {
  1101.     mSheet->MaxCols() =  mFields.count();
  1102.     mSheet->MaxRows() =  mFields.source()->count();
  1103.     mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT;
  1104.     mSheet->DisplayRowHeaders() = FALSE;
  1105.     mSheet->DisplayColHeaders() = TRUE;
  1106.     mSheet->AllowResize() = TRUE;
  1107. //    mSheet->VScrollSpecial() = TRUE;
  1108. //    mSheet->ScrollBarExtMode() = TRUE;
  1109.     mSheet->CursorStyle() = SS_CURSOR_STYLE_ARROW;
  1110.    selectFirst();
  1111. }
  1112.  
  1113.  
  1114. int dbSSBrowseTable::size(zSizeEvt* evt)
  1115. {
  1116.     int ret = zWindow::size(evt);
  1117.     SetColWidthsFromView();
  1118.     return ret;
  1119. }
  1120.  
  1121.  
  1122. void dbSSBrowseTable::receiveDoubleClick(long Col, long Row)
  1123. {
  1124.     if (mEditMgr)
  1125.         mEditMgr->doubleClickedBrowser(Row-1);
  1126. }
  1127.  
  1128.  
  1129. void dbSSBrowseTable::selectFirst()
  1130. {
  1131.     mCurRow = 1;
  1132.      selectRow(mCurRow);
  1133. }
  1134.  
  1135.  
  1136. void dbSSBrowseTable::selectNext()
  1137. {
  1138.      mCurRow++;
  1139.      selectRow(mCurRow);
  1140. }
  1141.  
  1142.  
  1143. void dbSSBrowseTable::selectPrev()
  1144. {
  1145.      mCurRow--;
  1146.      selectRow(mCurRow);
  1147. }
  1148.  
  1149.  
  1150. void dbSSBrowseTable::selectLast()
  1151. {
  1152.      mCurRow = mSheet->MaxRows();
  1153.      selectRow(mCurRow);
  1154. }
  1155.  
  1156.  
  1157. void dbSSBrowseTable::SetCellWidth(dbField* theField, char* contents)
  1158. {
  1159.     mSheet->TypeEditLen() = strlen(contents);
  1160. }
  1161.  
  1162.  
  1163.  
  1164. // -------------------------------------------------------
  1165. //                     d b S S E d i t T a b l e
  1166. // -------------------------------------------------------
  1167. dbSSEditTable::dbSSEditTable(zFrameWin*w, int id_, dbView& flds) :
  1168.                                             dbSSViewTable(w, id_, flds)
  1169. {
  1170.     SetupSheet();
  1171.     SetColsFromView();
  1172. }
  1173.  
  1174.  
  1175. void dbSSEditTable::SetupSheet()
  1176. {
  1177.     mSheet->MaxCols() =  mFields.count();
  1178.     mSheet->MaxRows() =  mFields.source()->count();
  1179.     mSheet->OperationMode() = SS_OP_MODE_NORMAL;
  1180. // was SS_OP_MODE_ROWMODE; but have problems with controls not visible in that case
  1181. // Mike Betham preferred look with normal - confusing with combo boxes having to
  1182. // double-click to enter editing mode then click again on the control
  1183.     mSheet->ProcessTab() = TRUE;  // tab cells, not controls
  1184.     mSheet->EditModePermanent() = TRUE;
  1185.     mSheet->DisplayRowHeaders() = FALSE;
  1186.     mSheet->DisplayColHeaders() = TRUE;
  1187.     mSheet->AllowResize() = TRUE;
  1188.     mSheet->CursorStyle() = SS_CURSOR_STYLE_ARROW;
  1189. }
  1190.  
  1191.  
  1192. unsigned long dbSSEditTable::appendBlankRow()
  1193. {
  1194.     unsigned long newRow = SSTable::appendBlankRow();
  1195.     mFields.source()->newRecord();
  1196.  
  1197.     unsigned int numFields = mFields.count();
  1198.     for (unsigned int col=0; col<numFields; col++) {        // start field iteration (horizontal)
  1199.         dbField  *theField = (dbField  *) mFields[col];           // safe downcast
  1200.         mSheet->Col() = col+1;
  1201.         dbSSViewTable::SetCellWidth(theField);
  1202.     }
  1203.     return newRow;
  1204. }
  1205.  
  1206.  
  1207. void dbSSEditTable::enterRow(long Row)
  1208. {
  1209.     if (mCurRow != Row) {
  1210.         mCurRow = Row;
  1211.         mFields.source()->gotoRelativeRecord(Row-1);
  1212.     }
  1213. }
  1214.  
  1215.  
  1216. void dbSSEditTable::leaveModifiedCell(long Col, long Row)
  1217. {
  1218.     assert(Row==mCurRow);
  1219.     mSheet->Col() = Col;
  1220.    mSheet->Row() = Row;
  1221.     char *cellText = mSheet->GetText(Col, Row);
  1222.     dbField  *theField = (dbField *) mFields[(int)(Col-1)];           // safe downcast
  1223.     theField->setString(cellText);
  1224.     adjustRowHeights();
  1225. }
  1226.  
  1227.  
  1228. // -------------------------------------------------------
  1229. //          d b z L i s t B r o w s e T a b l e
  1230. // -------------------------------------------------------
  1231. dbzListBrowseTable::dbzListBrowseTable(zWindow*w, zSizer* s, int id_, dbView& flds, DWORD style) :
  1232.                                             zListBox(w, s, style, 0, id_),
  1233.                                             mFields(flds)
  1234. {
  1235. }
  1236.  
  1237. void dbzListBrowseTable::loadEntireTable()
  1238. {
  1239.     mFields.source()->start();
  1240.    unsigned int numFields = mFields.count();
  1241.     while (mFields.source()->more()) {
  1242.         ostrstream oss;
  1243.         for (unsigned int col=0; col< numFields; col++) {        // start field iteration (horizontal)
  1244.             dbField  *theField = (dbField  *) mFields[col];           // safe downcast
  1245.             char* str = theField->copyAsChars() ;
  1246. //            oss.width(theField->FieldLen());
  1247. //            if (theField->FieldType()==charField)
  1248.  //                oss.setf(ios::left, ios::adjustfield);
  1249. //            else
  1250. //                oss.setf(ios::right, ios::adjustfield);
  1251.             oss << str << '\t';
  1252. //            delete[] str;
  1253.         }
  1254.         char* str = oss.str();
  1255.         if (str)
  1256.             add(str);
  1257.         mFields.source()->next();
  1258.     }
  1259. }
  1260.  
  1261.  
  1262.  
  1263.